import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:playtruly/common/routers/names.dart';
import 'package:playtruly/common/services/rongcloud_service.dart';
import 'package:playtruly/common/services/user_service.dart';
import 'package:rongcloud_im_wrapper_plugin/rongcloud_im_wrapper_plugin.dart';
import 'package:playtruly/common/api/user_api.dart';
import 'package:playtruly/common/api/friend_api.dart';
import 'package:playtruly/common/models/index.dart';
import 'package:playtruly/common/utils/toast_util.dart';
import 'package:playtruly/common/utils/smart_notification_util.dart';

import 'dart:developer' as developer;
import 'dart:async';
import '../message_index/controller.dart';

// 消息模型（参考MyApplication2的MessageBean）
class ChatMessage {
  final String content;
  final bool isMe;
  final DateTime timestamp;
  final String sender; // "1"=自己, "2"=朋友
  final String messageIfRead; // "0"=未读, "1"=已读
  final String? messageId; // 消息ID（用于融云消息标识）

  ChatMessage({
    required this.content,
    required this.isMe,
    DateTime? timestamp,
    String? sender,
    this.messageIfRead = "1",
    this.messageId,
  }) : timestamp = timestamp ?? DateTime.now(),
       sender = sender ?? (isMe ? "1" : "2");
  
  // 转换为JSON存储格式
  Map<String, dynamic> toJson() {
    return {
      'content': content,
      'isMe': isMe,
      'timestamp': timestamp.toIso8601String(),
      'sender': sender,
      'messageIfRead': messageIfRead,
      'messageId': messageId,
    };
  }
  
  // 从JSON恢复消息
  factory ChatMessage.fromJson(Map<String, dynamic> json) {
    return ChatMessage(
      content: json['content'] ?? '',
      isMe: json['isMe'] ?? false,
      timestamp: DateTime.tryParse(json['timestamp'] ?? '') ?? DateTime.now(),
      sender: json['sender'] ?? "1",
      messageIfRead: json['messageIfRead'] ?? "1",
      messageId: json['messageId'],
    );
  }
}

// 聊天用户模型（扩展支持更多用户信息）
class ChatUser {
  final String id;
  final String name;
  final String avatarUrl;
  final String? userGender;
  final int? userAge;
  final String? userSignature;
  final int? userLevel;
  final String? userCity;
  final List<String>? userTags;
  final String? userFrequentPlaces;
  final int? userLikes;
  final int? userFollowers;
  final int? userPoints;
  final String? userPhone;
  final String? userBirthday;

  ChatUser({
    required this.id,
    required this.name,
    required this.avatarUrl,
    this.userGender,
    this.userAge,
    this.userSignature,
    this.userLevel,
    this.userCity,
    this.userTags,
    this.userFrequentPlaces,
    this.userLikes,
    this.userFollowers,
    this.userPoints,
    this.userPhone,
    this.userBirthday,
  });

  // 从API响应创建ChatUser对象
  factory ChatUser.fromUserFilteredData(FilteredUserInfo userData) {
    return ChatUser(
      id: userData.userid.toString(),
      name: userData.username,
      avatarUrl: userData.userAvatarUrl ?? '',
      userGender: userData.userGender,
      userAge: userData.userAge,
      userSignature: userData.userSignature,
      userLevel: userData.userLevel,
      userCity: userData.userCity,
      userTags: userData.userTags,
      userFrequentPlaces: userData.userFrequentPlaces,
      userLikes: userData.userLikes,
      userFollowers: userData.userFollowers,
      userPoints: userData.userPoints,
      userPhone: userData.userPhone,
      userBirthday: userData.userBirthday,
    );
  }
}

class MessageChatController extends GetxController {
  // 🔥 控制器唯一标识（基于聊天用户ID）
  String? controllerTag;
  
  // 输入框控制器
  final messageController = TextEditingController();
  
  // 滚动控制器（用于自动滚动到底部）
  final scrollController = ScrollController();
  
  // 当前聊天用户
  ChatUser? chatUser;
  
  // 完整的用户信息（从API获取）
  Rx<FilteredUserInfo?> fullUserData = Rx<FilteredUserInfo?>(null);
  
  // 用户活动/动态数据（从API获取）
  RxList<ActivityData> userActivities = <ActivityData>[].obs;
  
  // 🔥 新架构：直接观察融云服务中的消息列表（不再使用本地消息列表）
  RxList<Map<String, dynamic>>? messagesFromService;
  
  // 加载状态
  final RxBool isLoadingUserInfo = false.obs;
  final RxBool isDeletingFriend = false.obs;
  
  // 当前用户信息（从SharedPreferences获取）
  final RxString currentUserId = ''.obs;
  final RxString currentUserName = ''.obs;
  final RxString currentUserAvatar = ''.obs;
  final RxString rongCloudToken = ''.obs;
  
  // 聊天状态
  final RxBool isConnected = false.obs;
  final RxBool isLoading = false.obs;
  final RxBool showScrollToBottomButton = false.obs; // 是否显示回到底部按钮
  
  // 分页参数（参考MyApplication2实现）
  int page = 0;
  final int pageSize = 10;
  
  // 🔥 订阅管理
  StreamSubscription<RCIMIWMessage>? _messageStreamSubscription;
  StreamSubscription<bool>? _connectionStatusSubscription;
  StreamSubscription? _messageReceivedSubscription;

  @override
  void onInit() {
    super.onInit();
    
    // 🔥 优先获取传递的参数并立即设置chatUser
    if (Get.arguments != null) {
      if (Get.arguments is ChatUser) {
        chatUser = Get.arguments as ChatUser;
      } else if (Get.arguments is Map<String, dynamic>) {
        final args = Get.arguments as Map<String, dynamic>;
        chatUser = ChatUser(
          id: args['userId']?.toString() ?? '',
          name: args['userName'] ?? '未知用户',
          avatarUrl: args['userAvatar'] ?? '',
        );
      }
      
      // 🔥 立即记录聊天对象信息，确保智能通知系统能获取到
      developer.log('🏷️ 聊天对象已设置: ${chatUser?.name} (ID: ${chatUser?.id})');
    } else {
      developer.log('⚠️ 未获取到聊天对象参数');
    }
    
    // 🔥 设置控制器唯一标识
    controllerTag = "message_chat_${chatUser?.id ?? 'unknown'}";
    developer.log('🏷️ 聊天控制器标识: $controllerTag');
    
    // 添加滚动监听器
    _setupScrollListener();
    
    // 初始化聊天（异步执行，不阻塞onInit）
    Future.microtask(() => _initializeChat());
  }

  // 设置滚动监听器
  void _setupScrollListener() {
    scrollController.addListener(() {
      if (!scrollController.hasClients) return;
      
      // 判断是否接近底部（距离底部小于100像素）
      final isNearBottom = scrollController.position.maxScrollExtent - scrollController.position.pixels < 100;
      
      // 更新按钮显示状态
      if (isNearBottom && showScrollToBottomButton.value) {
        showScrollToBottomButton.value = false;
      } else if (!isNearBottom && !showScrollToBottomButton.value && messagesFromService != null && messagesFromService!.isNotEmpty) {
        showScrollToBottomButton.value = true;
      }
    });
  }

  // 初始化聊天（优化版本 - 避免主线程阻塞）
  Future<void> _initializeChat() async {
    try {
      developer.log('🔄 =============== 初始化聊天（异步优化版本） ===============');
      developer.log('👤 聊天对象: ${chatUser?.name ?? "未知"}');
      
      // 🔥 第一阶段：快速初始化（同步执行，保证UI快速响应）
      _setupInitialState();
      
      // 🔥 第二阶段：异步初始化（后台执行，不阻塞UI）
      _performAsyncInitialization();
      
      developer.log('✅ 聊天快速初始化完成，后台继续异步加载');
      
    } catch (e) {
      developer.log('💥 聊天初始化异常: $e');
    }
  }

  /// 🔥 第一阶段：快速同步初始化（避免UI阻塞）
  void _setupInitialState() {
    try {
      developer.log('⚡ 开始快速初始化...');
      
      // 1. 立即清除通知缓存（快速操作）
      if (chatUser != null && chatUser!.id.isNotEmpty) {
        final rongCloudService = RongCloudService.to;
        rongCloudService.clearUserNewMessage(chatUser!.id);
        developer.log('🗑️ 快速清除用户 ${chatUser!.id} 的缓存');
      }
      
      // 2. 立即加载本地用户信息（快速操作）
      _loadUserInfoSync();
      
      // 3. 立即订阅融云状态（快速操作）
      _subscribeToRongCloudStatus();
      
      // 4. 立即连接消息服务（快速操作）
      _connectToMessagesServiceSync();
      
      developer.log('⚡ 快速初始化完成');
    } catch (e) {
      developer.log('💥 快速初始化异常: $e');
    }
  }

  /// 🔥 第二阶段：后台异步初始化（不阻塞UI）
  Future<void> _performAsyncInitialization() async {
    try {
      developer.log('🔄 开始后台异步初始化...');
      
      // 使用 Future.microtask 确保不阻塞当前帧
      Future.microtask(() async {
        try {
          // 1. 异步初始化智能通知系统
          await SmartNotificationUtil.instance.initialize();
          
          // 2. 异步清除通知队列
          if (chatUser != null && chatUser!.id.isNotEmpty) {
            await SmartNotificationUtil.instance.clearUserNotifications(chatUser!.id);
          }
          
          // 3. 异步加载用户详细信息
          await _loadChatUserFullInfo();
          
          // 4. 异步确保融云连接
          await _ensureRongCloudConnection();
          
          developer.log('✅ 后台异步初始化完成');
        } catch (e) {
          developer.log('💥 后台异步初始化异常: $e');
        }
      });
      
    } catch (e) {
      developer.log('💥 后台异步初始化设置异常: $e');
    }
  }

  /// 🔥 同步加载本地用户信息（快速操作）
  void _loadUserInfoSync() {
    try {
      final userService = UserService.to;
      currentUserId.value = userService.userId;
      currentUserName.value = userService.userName;
      currentUserAvatar.value = userService.userAvatar;
      rongCloudToken.value = userService.rongCloudToken ?? '';
      
      developer.log('👤 用户信息快速加载: ${currentUserName.value}');
    } catch (e) {
      developer.log('💥 同步加载用户信息异常: $e');
    }
  }

  /// 🔥 同步连接消息服务（快速操作）
  void _connectToMessagesServiceSync() {
    try {
      if (chatUser == null) return;
      
      final rongCloudService = RongCloudService.to;
      messagesFromService = rongCloudService.getUserMessages(chatUser!.id);
      
      if (messagesFromService != null) {
        developer.log('✅ 快速连接到消息列表，消息数: ${messagesFromService!.length}');
        
        // 🔥 打印消息内容用于调试
        for (int i = 0; i < messagesFromService!.length; i++) {
          final msg = messagesFromService![i];
          developer.log('📝 消息[$i]: ${msg['content']} (isMe: ${msg['isMe']})');
        }
        
        // 🔥 强制触发UI更新
        update();
        
        // 如果有消息，延迟滚动到底部（避免阻塞）
        if (messagesFromService!.isNotEmpty) {
          Future.delayed(const Duration(milliseconds: 100), () {
            scrollToBottom(animated: false);
          });
        }
      } else {
        developer.log('⚠️ messagesFromService为null，无法获取消息列表');
      }
    } catch (e) {
      developer.log('💥 同步连接消息服务异常: $e');
    }
  }

  // 获取聊天对象的完整用户信息
  Future<void> _loadChatUserFullInfo() async {
    if (chatUser == null || chatUser!.id.isEmpty) {
      developer.log('⚠️ 聊天对象信息不完整，跳过用户信息获取');
      return;
    }

    try {
      developer.log('🔄 =============== 获取聊天对象详细信息 ===============');
      developer.log('👤 目标用户ID: ${chatUser!.id}');
      developer.log('📝 请求内容类型: activities (获取活动动态)');
      
      isLoadingUserInfo.value = true;
      
      // 🔥 安全转换用户ID为整数，避免FormatException
      final userId = int.tryParse(chatUser!.id);
      if (userId == null) {
        developer.log('❌ 用户ID格式无效: ${chatUser!.id}');
        ToastUtil.error('用户ID格式错误，无法获取用户信息');
        return;
      }
      
      // 调用API获取用户详细信息和活动动态
      final response = await UserApi.getUserFilteredContent(
        userId: userId, // 🔥 使用安全转换后的用户ID
        contentType: 'activities', // 获取活动信息用于显示动态
      );
      
      developer.log('📨 API响应状态: ${response.status}');
      developer.log('📨 API响应消息: ${response.message}');
      
      if (response.isSuccess && response.user != null) {
        fullUserData.value = response.user!;
        
        // 更新用户活动/动态数据
        if (response.activities != null && response.activities!.isNotEmpty) {
          userActivities.value = response.activities!;
          developer.log('✅ 获取到用户活动数据: ${response.activities!.length}条');
          
          // 显示第一条活动的详细信息
          final firstActivity = response.activities!.first;
          developer.log('📝 最新活动:');
          developer.log('   标题: ${firstActivity.activityTitle}');
          developer.log('   内容: ${firstActivity.activityDetails}');
          developer.log('   图片数量: ${firstActivity.activityImages.length}');
          developer.log('   发布时间: ${firstActivity.activityPublishTime}');
          developer.log('   位置: ${firstActivity.activityLocation}');
          developer.log('   类型: ${firstActivity.activityType}');
        } else {
          userActivities.clear();
          developer.log('📝 该用户暂无活动数据');
        }
        
        // 更新chatUser对象
        chatUser = ChatUser.fromUserFilteredData(response.user!);
        
        developer.log('✅ 用户信息获取成功:');
        developer.log('   用户名: ${response.user!.username}');
        developer.log('   性别: ${response.user!.userGender}');
        developer.log('   年龄: ${response.user!.userAge}');
        developer.log('   等级: ${response.user!.userLevel}');
        developer.log('   签名: ${response.user!.userSignature}');
        developer.log('   城市: ${response.user!.userCity}');
        
      } else {
        developer.log('❌ API响应失败: ${response.message ?? "未知错误"}');
        // 🔥 根据不同的错误类型给出更具体的提示
        if (response.message?.contains('用户不存在') == true || response.message?.contains('User not found') == true) {
          ToastUtil.warning('用户不存在或已被删除');
        } else if (response.message?.contains('权限') == true || response.message?.contains('permission') == true) {
          ToastUtil.warning('没有权限访问该用户信息');
        } else {
          ToastUtil.warning('获取用户信息失败: ${response.message ?? "网络错误"}');
        }
      }
      
    } catch (e) {
      developer.log('💥 获取用户信息异常: $e');
      // 🔥 根据异常类型给出更具体的错误提示
      if (e is FormatException) {
        ToastUtil.error('用户ID格式错误');
      } else if (e.toString().contains('timeout') || e.toString().contains('network')) {
        ToastUtil.error('网络连接超时，请检查网络后重试');
      } else {
        ToastUtil.error('获取用户信息异常: ${e.toString()}');
      }
    } finally {
      isLoadingUserInfo.value = false;
      developer.log('🔄 用户信息加载状态设置为: false');
    }
  }


  // 🔥 简化的融云状态订阅（参考MyApplication2架构）
  void _subscribeToRongCloudStatus() {
    try {
      developer.log('🚀 =============== 订阅融云状态 ===============');
      
      final rongCloudService = RongCloudService.to;
      
      // 🔥 只监听全局状态，不进行连接操作
      _connectionStatusSubscription = rongCloudService.isConnected.listen((connected) {
        isConnected.value = connected;
        developer.log('🔗 融云连接状态变化: $connected');
        update(); // 更新UI
      });
      
      // 🔥 订阅全局消息流（直接监听新消息）
      _messageStreamSubscription = rongCloudService.messageStream.listen((message) {
        developer.log('📥 聊天页面接收到消息流: ${_extractMessageContent(message)}');
        _handleRongCloudMessage(message);
      });
      
      // 🔥 订阅缓存消息变化（备用机制）
      // TODO: 重新实现缓存消息订阅机制
      // _messageReceivedSubscription = rongCloudService.cachedMessages.listen((messages) {
      //   if (chatUser != null && messages.containsKey(chatUser!.id)) {
      //     developer.log('📥 收到缓存消息，更新聊天列表');
      //     _refreshMessagesFromCache();
      //   }
      // });
      
      // 🔥 初始状态同步
      isConnected.value = rongCloudService.isConnected.value;
      
      developer.log('✅ 融云状态订阅完成，当前状态: ${isConnected.value}');
      
    } catch (e) {
      developer.log('💥 订阅融云状态异常: $e');
    }
  }

  // 🔥 确保融云连接（非阻塞，委托给服务层）
  Future<void> _ensureRongCloudConnection() async {
    try {
      final rongCloudService = RongCloudService.to;
      
      // 🔥 检查当前连接状态
      if (rongCloudService.isConnected.value) {
        developer.log('✅ 融云已连接，无需重新连接');
        return;
      }
      
      // 🔥 委托给服务层连接（非阻塞）
      developer.log('🔄 聊天页面请求融云连接');
      rongCloudService.connectIM(); // 不等待结果，让页面正常显示
      
    } catch (e) {
      developer.log('💥 确保融云连接异常: $e');
    }
  }



  // 🔥 新架构：发送消息（使用统一消息管理）
  Future<void> sendMessage() async {
    final text = messageController.text.trim();
    if (text.isEmpty) {
      ToastUtil.warning('请输入要发送的消息');
      return;
    }
    
    if (chatUser == null) return;
    
    try {
      developer.log('📤 =============== 发送消息 ===============');
      developer.log('💬 消息内容: $text');
      developer.log('👤 目标用户: ${chatUser!.name} (ID: ${chatUser!.id})');
      
      final rongCloudService = RongCloudService.to;
      
      // 1. 🔥 先添加到融云服务的消息管理系统
      rongCloudService.addMessageToUser(
        userId: chatUser!.id,
        content: text,
        isMe: true,
        messageId: DateTime.now().millisecondsSinceEpoch.toString(),
        senderName: currentUserName.value,
        senderAvatar: currentUserAvatar.value,
      );
      
      developer.log('✅ 消息已添加到融云服务消息列表');
      
      // 2. 清空输入框
      messageController.clear();
      
      // 3. 自动滚动到底部
      Future.delayed(const Duration(milliseconds: 100), () {
        scrollToBottom(animated: true);
      });
      
      // 4. 通过融云发送消息（异步，不阻塞UI）
      _sendMessageViaRongCloud(text);
      
      developer.log('✅ 消息发送流程完成');
      
    } catch (e) {
      developer.log('💥 发送消息异常: $e');
      ToastUtil.error('消息发送失败，请重试');
    }
  }

  // 通过融云发送消息（修复版本 - 使用正确的融云用户ID）
  Future<void> _sendMessageViaRongCloud(String messageText) async {
    try {
      if (chatUser == null) {
        developer.log('⚠️ 聊天对象为空');
        return;
      }
      
      final rongCloudService = RongCloudService.to;
      
      developer.log('🚀 发送融云消息...');
      
      // 🔥 修复：获取目标用户的融云用户ID（这是关键！）
      String? targetRongCloudUserId;
      
      // 从extraData中获取融云用户ID
      if (fullUserData.value?.extraData != null && fullUserData.value!.extraData!['rongcloud_user_id'] != null) {
        targetRongCloudUserId = fullUserData.value!.extraData!['rongcloud_user_id'].toString();
        developer.log('🎯 从extraData获取融云ID: $targetRongCloudUserId');
      } else {
        developer.log('⚠️ 无法从extraData获取目标用户融云ID，将使用手机号作为备选');
        // 备选方案：使用手机号
        if (fullUserData.value?.userPhone != null && fullUserData.value!.userPhone!.isNotEmpty) {
          targetRongCloudUserId = fullUserData.value!.userPhone!;
          developer.log('📱 使用手机号作为备选: $targetRongCloudUserId');
        }
      }
      
      if (targetRongCloudUserId == null || targetRongCloudUserId.isEmpty) {
        developer.log('❌ 无法确定目标用户的融云ID，消息发送失败');
        ToastUtil.error('无法发送消息：目标用户信息不完整');
        return;
      }
      
      // 发送消息
      final success = await rongCloudService.sendTextMessage(
        targetId: targetRongCloudUserId, // 🔥 使用正确的融云用户ID
        content: messageText,
      );
      
      if (success) {
        developer.log('✅ 消息发送成功');
      } else {
        developer.log('❌ 消息发送失败');
        ToastUtil.warning('消息发送失败，已保存到本地');
      }
      
    } catch (e) {
      developer.log('💥 发送消息异常: $e');
    }
  }


  // 接收消息（融云消息监听器回调）
  Future<void> onReceiveMessage(String messageContent, String senderId) async {
    try {
      developer.log('📥 接收到消息: $messageContent (来自: $senderId)');
      
      
      // 🔥 新架构：添加到融云服务的消息管理系统
      final rongCloudService = RongCloudService.to;
      rongCloudService.addMessageToUser(
        userId: chatUser?.id ?? 'unknown',
        content: messageContent,
        isMe: false,
        messageId: DateTime.now().millisecondsSinceEpoch.toString(),
        senderName: "对方",
        senderAvatar: "",
      );
      
      // 自动滚动到底部
      Future.delayed(const Duration(milliseconds: 100), () {
        scrollToBottom(animated: true);
      });
      
      developer.log('✅ 消息接收处理完成');
      
    } catch (e) {
      developer.log('💥 接收消息处理异常: $e');
    }
  }

  // 🔥 将融云用户ID转换为数据库用户ID的映射函数
  String _convertRongCloudUserIdToDatabaseUserId(String rongCloudUserId) {
    // 临时方案：从已知的映射关系中查找
    // TODO: 将来应该从API或缓存中动态获取映射关系
    const rongCloudToDbUserIdMap = {
      '13482276617': '57', // 面包树的映射关系
      '15527877711': '3',  // 武汉玩真的的映射关系
    };
    
    String databaseUserId = rongCloudToDbUserIdMap[rongCloudUserId] ?? rongCloudUserId;
    developer.log('🔄 融云用户ID映射: $rongCloudUserId → $databaseUserId');
    return databaseUserId;
  }

  // 处理融云消息（消息监听器回调）
  Future<void> _handleRongCloudMessage(dynamic message) async {
    try {
      developer.log('📥 =============== 聊天页面消息处理 ===============');
      
      // 🔥 修复：检查消息是否来自当前聊天对象（使用融云用户ID匹配）
      if (chatUser == null) {
        developer.log('📥 聊天对象为空，忽略消息');
        return;
      }
      
      // 获取发送者的融云用户ID
      final senderRongCloudUserId = message.senderUserId?.toString();
      if (senderRongCloudUserId == null || senderRongCloudUserId.isEmpty) {
        developer.log('📥 消息发送者融云ID为空，忽略消息');
        return;
      }
      
      // 获取当前聊天对象的融云用户ID
      String? targetRongCloudUserId;
      if (fullUserData.value?.extraData != null && fullUserData.value!.extraData!['rongcloud_user_id'] != null) {
        targetRongCloudUserId = fullUserData.value!.extraData!['rongcloud_user_id'].toString();
      }
      
      developer.log('📥 当前聊天页面信息:');
      developer.log('   👤 聊天对象: ${chatUser!.name} (数据库ID: ${chatUser!.id})');
      developer.log('   🎯 聊天对象融云ID: $targetRongCloudUserId');
      developer.log('📥 收到消息信息:');
      developer.log('   📱 发送者融云ID: $senderRongCloudUserId');
      developer.log('   💬 消息内容: ${_extractMessageContent(message)}');
      
      // 检查是否匹配
      if (targetRongCloudUserId == null || senderRongCloudUserId != targetRongCloudUserId) {
        developer.log('📥 =============== 消息过滤说明 ===============');
        developer.log('📥 消息来源: $senderRongCloudUserId');
        developer.log('📥 当前聊天对象: $targetRongCloudUserId');
        developer.log('📥 ❌ 消息不是来自当前聊天对象，正确过滤');
        developer.log('📥 💡 这是正确的设计：聊天页面只显示与当前用户的消息');
        developer.log('📥 💡 其他用户的消息会在聊天列表中显示通知');
        developer.log('📥 💡 如需查看该消息，请返回聊天列表并点击对应用户');
        developer.log('📥 =============== 消息过滤完成 ===============');
        return;
      }
      
      developer.log('✅ 消息来自当前聊天对象，开始处理...');
      
      final messageContent = _extractMessageContent(message);
      developer.log('📥 处理融云消息: $messageContent');
      
      // 创建接收的消息对象
      final receivedMessage = ChatMessage(
        content: messageContent,
        isMe: false,
        sender: "2", // 朋友
        messageIfRead: "1",
        messageId: message.messageId?.toString(),
        timestamp: DateTime.fromMillisecondsSinceEpoch(message.sentTime ?? DateTime.now().millisecondsSinceEpoch),
      );
      
      developer.log('📥 =============== 消息接收处理 ===============');
      developer.log('💬 消息内容: $messageContent');
      developer.log('👤 发送者: ${chatUser!.name}');
      developer.log('⏰ 消息时间: ${receivedMessage.timestamp}');
      
      // 🔥 新架构：消息已通过统一系统处理，这里只需要滚动
      // （消息已在_handleReceivedMessage中添加到统一管理系统）
      
      // 自动滚动到底部
      Future.delayed(const Duration(milliseconds: 100), () {
        scrollToBottom(animated: true);
      });
      developer.log('💾 消息已保存到本地存储');
      
      developer.log('📥 =============== 消息接收处理完成 ===============');
      
      // 🔔 智能通知处理 - 检测页面状态并决定通知方式
      // 🔥 修复：使用正确的发送者数据库用户ID，而不是当前聊天对象ID
      final senderDatabaseUserId = _convertRongCloudUserIdToDatabaseUserId(senderRongCloudUserId);
      await _handleSmartNotification(
        senderUserId: senderDatabaseUserId, // 🔥 使用发送者的数据库用户ID
        senderName: chatUser?.name ?? '未知用户',
        senderAvatar: chatUser?.avatarUrl ?? '',
        messageContent: messageContent,
        messageId: message.messageId?.toString(), // 🔥 传递消息ID用于去重
      );
      
      developer.log('✅ 融云消息处理完成');
      
    } catch (e) {
      developer.log('💥 处理融云消息异常: $e');
    }
  }

  // 智能通知处理方法
  Future<void> _handleSmartNotification({
    required String senderUserId,
    required String senderName,
    required String senderAvatar,
    required String messageContent,
    String? messageId, // 🔥 新增消息ID参数
  }) async {
    try {
      developer.log('🔔 =============== 开始智能通知处理 ===============');
      
      // 🔥 从fullUserData获取发送者的完整信息（头像等）
      String finalSenderName = senderName;
      String finalSenderAvatar = senderAvatar;
      
      if (fullUserData.value != null) {
        finalSenderName = fullUserData.value!.username;
        finalSenderAvatar = fullUserData.value!.userAvatarUrl ?? '';
        developer.log('🎭 使用API获取的发送者信息: $finalSenderName');
        developer.log('🖼️ 发送者头像: $finalSenderAvatar');
      }
      
      // 获取当前聊天页面的用户ID
      final currentChatUserId = chatUser?.id;
      
      // 调用智能通知工具处理
      await SmartNotificationUtil.instance.handleMessageNotification(
        senderUserId: senderUserId,
        senderName: finalSenderName,
        senderAvatar: finalSenderAvatar,
        messageContent: messageContent,
        currentChatUserId: currentChatUserId,
        messageId: messageId, // 🔥 传递消息ID用于去重
      );
      
      developer.log('✅ 智能通知处理完成');
      
    } catch (e) {
      developer.log('💥 智能通知处理异常: $e');
    }
  }

  // 提取消息内容（增强版本，支持多种消息类型）
  String _extractMessageContent(dynamic message) {
    try {
      developer.log('🔍 开始提取消息内容，消息类型: ${message?.runtimeType}');
      
      // 检查消息是否为空
      if (message == null) {
        developer.log('⚠️ 消息为null');
        return '[空消息]';
      }
      
      // 尝试多种方式提取内容
      String content = '[未知消息]';
      
      // 方式1: 直接访问text字段（适用于RCIMIWTextMessage）
      if (message.text != null && message.text is String && message.text.toString().isNotEmpty) {
        content = message.text.toString();
        developer.log('✅ 通过text字段提取: $content');
        return content;
      }
      
      // 方式2: 通过content字段提取
      if (message.content != null) {
        final contentObj = message.content;
        developer.log('🔍 Content对象类型: ${contentObj.runtimeType}');
        
        // 检查是否是文本消息
        if (contentObj.text != null && contentObj.text is String) {
          content = contentObj.text.toString();
          developer.log('✅ 通过content.text提取: $content');
          return content;
        }
        
        // 检查是否有content字段
        if (contentObj.content != null && contentObj.content is String) {
          content = contentObj.content.toString();
          developer.log('✅ 通过content.content提取: $content');
          return content;
        }
        
        // 尝试调用encode方法
        try {
          final encoded = contentObj.encode();
          if (encoded != null && encoded.toString().isNotEmpty) {
            content = encoded.toString();
            developer.log('✅ 通过encode()提取: $content');
            return content;
          }
        } catch (encodeError) {
          developer.log('⚠️ encode()调用失败: $encodeError');
        }
        
        // 尝试toString()
        final contentString = contentObj.toString();
        if (contentString.isNotEmpty && contentString != 'Instance of \'RCIMIWTextMessage\'') {
          content = contentString;
          developer.log('✅ 通过toString()提取: $content');
          return content;
        }
      }
      
      // 方式3: 检查消息的其他字段
      final messageString = message.toString();
      if (messageString.contains('text:') || messageString.contains('content:')) {
        // 尝试从toString()结果中提取内容
        final patterns = [
          RegExp(r'text:\s*([^,}]+)'),
          RegExp(r'content:\s*([^,}]+)'),
        ];
        
        for (final pattern in patterns) {
          final match = pattern.firstMatch(messageString);
          if (match != null && match.group(1) != null) {
            content = match.group(1)!.trim();
            developer.log('✅ 通过正则表达式提取: $content');
            return content;
          }
        }
      }
      
      // 方式4: 最后尝试 - 检查消息类型
      final messageType = message.messageType ?? message.type ?? 0;
      switch (messageType) {
        case 1: // 文本消息
          content = '[文本消息]';
          break;
        case 2: // 图片消息
          content = '[图片消息]';
          break;
        case 3: // 语音消息
          content = '[语音消息]';
          break;
        case 4: // 视频消息
          content = '[视频消息]';
          break;
        case 5: // 文件消息
          content = '[文件消息]';
          break;
        default:
          content = '[不支持的消息类型: $messageType]';
          break;
      }
      
      developer.log('⚠️ 使用默认消息类型解析: $content');
      return content;
      
    } catch (e) {
      developer.log('💥 提取消息内容异常: $e');
      developer.log('💥 消息详细: ${message?.toString()}');
      return '[消息解析失败: ${e.toString()}]';
    }
  }

  // 🔥 新增：删除好友前实时刷新用户信息（模仿MyApplication2的实现）
  Future<void> refreshUserInfoForDelete() async {
    if (chatUser == null || chatUser!.id.isEmpty) {
      developer.log('⚠️ 聊天对象信息不完整，无法刷新用户信息');
      return;
    }

    try {
      developer.log('🔄 =============== 删除好友前刷新用户信息 ===============');
      developer.log('👤 目标用户ID: ${chatUser!.id}');
      developer.log('📝 请求内容类型: activities (获取最新用户信息)');
      
      isLoadingUserInfo.value = true;
      
      // 🔥 安全转换用户ID为整数
      final userId = int.tryParse(chatUser!.id);
      if (userId == null) {
        developer.log('❌ 用户ID格式无效: ${chatUser!.id}');
        ToastUtil.error('用户ID格式错误，无法获取用户信息');
        return;
      }
      
      // 🔥 参考MyApplication2，获取用户完整信息
      developer.log('🚀 开始获取用户最新信息...');
      final response = await UserApi.getUserFilteredContent(
        userId: userId,
        contentType: 'activities', // 获取活动信息
      );
      
      developer.log('📨 刷新用户信息API响应状态: ${response.status}');
      
      if (response.isSuccess && response.user != null) {
        // 🔥 更新用户完整信息
        fullUserData.value = response.user!;
        developer.log('✅ 用户基本信息已更新: ${response.user!.username}');
        
        // 🔥 更新用户活动数据
        if (response.activities != null) {
          userActivities.value = response.activities!;
          developer.log('✅ 用户活动数据已更新: ${response.activities!.length}条');
        }
        
        // 🔥 输出关键用户信息用于验证
        final user = response.user!;
        developer.log('👤 刷新后的用户信息:');
        developer.log('   📛 用户名: ${user.username}');
        developer.log('   🆔 用户ID: ${user.userid}');
        developer.log('   🔗 头像: ${user.userAvatarUrl}');
        developer.log('   ⭐ 等级: ${user.userLevel}');
        developer.log('   👥 粉丝数: ${user.userFollowers}');
        developer.log('   👍 点赞数: ${user.userLikes}');
        developer.log('   ✍️ 签名: ${user.userSignature}');
        developer.log('   🏷️ 标签: ${user.userTags}');
        developer.log('   🏙️ 城市: ${user.userCity}');
        developer.log('   📍 常出没地: ${user.userFrequentPlaces}');
        
        developer.log('✅ 删除好友前用户信息刷新完成');
      } else {
        developer.log('❌ 刷新用户信息失败: ${response.message}');
        ToastUtil.error('获取最新用户信息失败');
      }
      
    } catch (e) {
      developer.log('💥 刷新用户信息异常: $e');
      ToastUtil.error('刷新用户信息失败: $e');
    } finally {
      isLoadingUserInfo.value = false;
    }
  }

  // 删除好友（使用真实API）
  Future<void> deleteFriend() async {
    if (chatUser == null || chatUser!.id.isEmpty) {
      ToastUtil.error('用户信息不完整');
      return;
    }

    try {
      developer.log('🔄 =============== 开始删除好友 ===============');
      developer.log('👤 当前用户ID: ${currentUserId.value}');
      developer.log('👤 好友ID: ${chatUser!.id}');
      
      isDeletingFriend.value = true;
      
      // 调用删除好友API
      final response = await FriendApi.deleteFriend(
        userId: int.parse(currentUserId.value),
        friendId: int.parse(chatUser!.id),
      );
      
      if (response.isSuccess) {
        developer.log('✅ 好友删除成功: ${response.message}');
        ToastUtil.success('好友已删除');
        
        // 清空本地聊天记录
        await clearChatHistory();
        
        // 🎯 先关闭删除确认弹窗
        Get.back(); // 关闭删除确认弹窗
        developer.log('✅ 删除确认弹窗已关闭');
        
        // 🔄 添加短暂延迟确保弹窗完全关闭
        await Future.delayed(const Duration(milliseconds: 300));
        
        // 🚀 明确跳转到聊天列表页面
        developer.log('🚀 开始跳转到聊天列表页面...');
        developer.log('🔧 目标路由: ${RouteNames.messageMessageIndex}');
        
        // 🎯 使用更安全的跳转方式，确保控制器正确初始化
        Get.offAndToNamed(RouteNames.messageMessageIndex);
        developer.log('✅ 跳转命令已发送');
        
        // 🔥 延迟执行删除好友和刷新操作，确保页面已经跳转完成
        Future.delayed(const Duration(milliseconds: 500), () {
          // 立即从聊天列表中移除被删除的好友
          _removeDeletedFriendFromChatList(chatUser!.id);
          
          // 再延迟一点时间刷新列表，作为双重保险
          Future.delayed(const Duration(milliseconds: 500), () {
            _tryRefreshChatList(retryCount: 3);
          });
        });
        
      } else {
        developer.log('❌ 好友删除失败: ${response.message}');
        ToastUtil.error(response.message);
      }
      
    } catch (e) {
      developer.log('💥 删除好友异常: $e');
      ToastUtil.error('删除好友失败，请重试');
    } finally {
      isDeletingFriend.value = false;
    }
  }

  // 🔥 新架构：清空聊天记录
  Future<void> clearChatHistory() async {
    try {
      if (chatUser == null) return;
      
      developer.log('🗑️ 清空聊天记录...');
      
      final rongCloudService = RongCloudService.to;
      
      // 🔥 清空融云服务中的消息列表
      rongCloudService.clearUserMessages(chatUser!.id);
      
      ToastUtil.success('聊天记录已清空');
      developer.log('✅ 聊天记录清空完成');
      
    } catch (e) {
      developer.log('💥 清空聊天记录异常: $e');
      ToastUtil.error('清空聊天记录失败');
    }
  }

  // 立即从聊天列表中移除被删除的好友
  void _removeDeletedFriendFromChatList(String deletedFriendId) {
    try {
      developer.log('🗑️ =============== 立即移除被删除好友 ===============');
      developer.log('👤 被删除的好友ID: $deletedFriendId');
      
      final controller = Get.find<MessageIndexController>();
      
      // 调用MessageIndexController的公共方法来移除好友
      controller.removeFriendById(deletedFriendId);
      developer.log('✅ 已调用MessageIndexController.removeFriendById()');
      
    } catch (e) {
      developer.log('💥 立即移除好友失败: $e');
      developer.log('🔄 将依赖后续API刷新来更新列表');
    }
  }

  // 尝试刷新聊天列表（带重试机制）
  void _tryRefreshChatList({int retryCount = 3}) {
    try {
      final controller = Get.find<MessageIndexController>();
      controller.onPageResumed();
      developer.log('✅ 聊天列表页面刷新成功');
    } catch (e) {
      developer.log('⚠️ 无法找到MessageIndexController (剩余重试次数: ${retryCount - 1}): $e');
      
      if (retryCount > 1) {
        // 重试，延迟时间递增
        Future.delayed(Duration(milliseconds: 1000 * (4 - retryCount)), () {
          _tryRefreshChatList(retryCount: retryCount - 1);
        });
      } else {
        developer.log('💥 所有重试都失败了，聊天列表将在页面加载时自动刷新');
      }
    }
  }

  // 🔥 新增：获取最新的用户API响应数据（包含friendCount）
  Future<UserFilteredContentResponse?> _getLatestUserResponse() async {
    if (chatUser == null || chatUser!.id.isEmpty) {
      return null;
    }

    try {
      final userId = int.tryParse(chatUser!.id);
      if (userId == null) {
        return null;
      }

      // 调用API获取最新数据（包含friendCount）
      final response = await UserApi.getUserFilteredContent(
        userId: userId,
        contentType: 'activities',
      );

      return response.isSuccess ? response : null;
    } catch (e) {
      developer.log('💥 获取最新用户响应异常: $e');
      return null;
    }
  }

  // 查看用户个人中心
  Future<void> viewUserProfile() async {
    // 导航到用户个人主页
    if (chatUser != null) {
      // 🔥 修复：传递完整的用户信息，包括API获取的详细数据和活动信息
      final userArguments = <String, dynamic>{
        'userId': int.tryParse(chatUser!.id) ?? 0,
        'username': chatUser!.name,
        'avatar': chatUser!.avatarUrl,
        'userGender': chatUser!.userGender,
        'userAge': chatUser!.userAge,
        'userSignature': chatUser!.userSignature,
        'userLevel': chatUser!.userLevel,
        'userCity': chatUser!.userCity,
        'userTags': chatUser!.userTags,
        'userFrequentPlaces': chatUser!.userFrequentPlaces,
        'userLikes': chatUser!.userLikes,
        'userFollowers': chatUser!.userFollowers,
        'userPoints': chatUser!.userPoints,
        'userPhone': chatUser!.userPhone,
        'userBirthday': chatUser!.userBirthday,
      };
      
      // 如果有从API获取的完整用户信息，优先使用API数据
      if (fullUserData.value != null) {
        final apiUser = fullUserData.value!;
        userArguments.addAll({
          'userId': apiUser.userid,
          'username': apiUser.username,
          'avatar': apiUser.userAvatarUrl,
          'userGender': apiUser.userGender,
          'userAge': apiUser.userAge,
          'userSignature': apiUser.userSignature,
          'userLevel': apiUser.userLevel,
          'userCity': apiUser.userCity,
          'userTags': apiUser.userTags,
          'userFrequentPlaces': apiUser.userFrequentPlaces,
          'userLikes': apiUser.userLikes,
          'userFollowers': apiUser.userFollowers,
          'userPoints': apiUser.userPoints,
          'userPhone': apiUser.userPhone,
          'userBirthday': apiUser.userBirthday,
          'userImgUrls': apiUser.userImgUrls,
          'userHobbies': apiUser.userHobbies,
        });
      }
      
      // 🔥 修复：添加好友数量字段（个人主页需要此字段显示粉丝数）
      // 从getUserFilteredContent API响应中获取friendCount
      final response = await _getLatestUserResponse();
      if (response != null && response.friendCount != null) {
        userArguments['friendCount'] = response.friendCount!;
        developer.log('✅ 传递好友数量到个人主页: ${response.friendCount}');
      } else {
        developer.log('⚠️ 无法获取好友数量，使用默认值0');
        userArguments['friendCount'] = 0;
      }
      
      // 添加活动信息
      if (userActivities.isNotEmpty) {
        userArguments['activities'] = userActivities;
      }
      
      developer.log('🎯 =============== 跳转用户主页 ===============');
      developer.log('👤 目标用户: ${userArguments['username']}');
      developer.log('🆔 用户ID: ${userArguments['userId']}');
      developer.log('🎭 用户头像: ${userArguments['avatar']}');
      developer.log('📱 传递的数据字段: ${userArguments.keys.toList()}');
      developer.log('🎯 =============== 用户主页跳转完成 ===============');
      
      Get.toNamed(RouteNames.myUserInfo, arguments: userArguments);
    }
  }

  // 手动重新连接融云
  Future<void> manualReconnectRongCloud() async {
    try {
      developer.log('🔄 =============== 用户手动重连融云 ===============');
      
      if (rongCloudToken.value.isEmpty) {
        developer.log('❌ Token为空，无法重连');
        Get.snackbar(
          '连接失败',
          '用户Token为空，请重新登录',
          backgroundColor: Colors.red.withOpacity(0.8),
          colorText: Colors.white,
          duration: const Duration(seconds: 3),
          snackPosition: SnackPosition.TOP,
        );
        return;
      }
      
      // 显示重连中提示
      Get.snackbar(
        '正在重连',
        '正在尝试重新连接融云服务...',
        backgroundColor: Colors.blue.withOpacity(0.8),
        colorText: Colors.white,
        duration: const Duration(seconds: 2),
        snackPosition: SnackPosition.TOP,
      );
      
      // 使用新的强制重连逻辑
      final rongCloudService = RongCloudService.to;
      final success = await rongCloudService.connectIM(forceReconnect: true);
      
      if (success) {
        // 等待连接状态回调
        await Future.delayed(const Duration(seconds: 2));
        
        if (rongCloudService.isConnected.value) {
          isConnected.value = true;
          Get.snackbar(
            '连接成功',
            '融云服务已恢复连接',
            backgroundColor: Colors.green.withOpacity(0.8),
            colorText: Colors.white,
            duration: const Duration(seconds: 2),
            snackPosition: SnackPosition.TOP,
          );
        } else {
          Get.snackbar(
            '连接失败',
            '融云服务连接超时，请稍后重试',
            backgroundColor: Colors.orange.withOpacity(0.8),
            colorText: Colors.white,
            duration: const Duration(seconds: 3),
            snackPosition: SnackPosition.TOP,
          );
        }
      } else {
        Get.snackbar(
          '连接失败',
          '融云服务连接失败，请检查网络',
          backgroundColor: Colors.red.withOpacity(0.8),
          colorText: Colors.white,
          duration: const Duration(seconds: 3),
          snackPosition: SnackPosition.TOP,
        );
      }
      
    } catch (e) {
      developer.log('💥 手动重连异常: $e');
      Get.snackbar(
        '连接失败',
        '重连过程出现异常: $e',
        backgroundColor: Colors.red.withOpacity(0.8),
        colorText: Colors.white,
        duration: const Duration(seconds: 3),
        snackPosition: SnackPosition.TOP,
      );
    }
  }

  // 自动滚动到消息列表底部
  Future<void> scrollToBottom({bool animated = true}) async {
    try {
      if (scrollController.hasClients && messagesFromService != null && messagesFromService!.isNotEmpty) {
        if (animated) {
          await scrollController.animateTo(
            scrollController.position.maxScrollExtent,
            duration: const Duration(milliseconds: 300),
            curve: Curves.easeOut,
          );
        } else {
          scrollController.jumpTo(scrollController.position.maxScrollExtent);
        }
        developer.log('📍 已滚动到消息列表底部');
      }
    } catch (e) {
      developer.log('💥 滚动到底部失败: $e');
    }
  }

  @override
  void onClose() {
    // 🔥 取消所有订阅
    _messageStreamSubscription?.cancel();
    _connectionStatusSubscription?.cancel();
    _messageReceivedSubscription?.cancel();
    
    messageController.dispose();
    scrollController.dispose();
    super.onClose();
  }
}
